package com.czy.jdk8.stream;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author czy
 * @date 2022-4-2 9:36
 */
public class StreamTest2 {
    // 交易员类
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class Trader {
        private String name;
        private String city;
    }

    // 交易类
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class Transaction {
        private Trader trader;
        private Integer year;
        private Integer value;
    }

    private Trader raoulA = new Trader("交易员A", "北京");
    private Trader raoulB = new Trader("交易员B", "上海");
    private Trader raoulC = new Trader("交易员C", "北京");
    private Trader raoulD = new Trader("交易员D", "武汉");
//    private Trader raoulE = new Trader("交易员E", "杭州");
//    private Trader raoulF = new Trader("交易员F", "重庆");
//    private Trader raoulG = new Trader("交易员G", "天津");
    private List<Transaction> transactionList = Arrays.asList(
            new Transaction(raoulA, 2011, 300),
            new Transaction(raoulB, 2012, 1000),
            new Transaction(raoulB, 2011, 400),
            new Transaction(raoulC, 2012, 710),
            new Transaction(raoulC, 2012, 700),
            new Transaction(raoulD, 2012, 950)
    );


    @Test
    public void t1(){
        //1.找出2011年发生的所有交易，并按交易额排序（从高到低）。
        List<Transaction> list = transactionList.stream()
                .filter(item -> item.getYear() == 2011)
                .sorted((a, b) -> b.getValue() - a.getValue())
                .collect(Collectors.toList());
        list.stream().forEach(System.out::println);
    }

    @Test
    public void t2(){
        //2.交易员都在哪些不同的城市工作过？
        // 方式一
//        List<String> cits = transactionList.stream()
//                .map(item -> item.getTrader().getCity())
//                .distinct()
//                .collect(Collectors.toList());

        // 方式二
        List<String> cits = transactionList.stream()
                .map(Transaction::getTrader)
                .map(Trader::getCity)
                .distinct()
                .collect(Collectors.toList());
        System.out.println(cits);

    }

    @Test
    public void t3(){
        // 3.查找所有来自北京的交易员，并按姓名排序。
        List<Trader> list = transactionList.stream()
                .map(Transaction::getTrader)
                .filter(item -> "北京".equals(item.getCity()))
                .sorted((a, b) -> a.getName().length() - b.getName().length())
                .collect(Collectors.toList());
        System.out.println(list);

    }

    @Test
    public void t4(){
        // 4.返回所有交易员的姓名字符串，按字母顺序排序。
        List<String> list = transactionList.stream()
                .map(Transaction::getTrader)
                .map(Trader::getName)
                .distinct()
                .sorted(String::compareTo)
                .collect(Collectors.toList());
        System.out.println(list);
    }

    @Test
    public void t5(){
        // 5.有没有交易员在 武汉 工作
        List<String> list = transactionList.stream()
                .map(item -> item.getTrader())
                .filter(item -> "武汉".equals(item.city))
                .map(Trader::getName)
                .distinct()
                .collect(Collectors.toList());
        System.out.println(list);
    }

    @Test
    public void t6(){
        // 6.打印生活在 北京 的交易员的所有交易额。
        // 方法一
//        Integer reduce = transactionList.stream()
//                .filter(item -> "北京".equals(item.getTrader().getCity()))
//                .map(item -> item.getValue())
//                .reduce(0, Integer::sum);
//        System.out.println(reduce);

        // 方法二
        Integer collect = transactionList.stream()
                .filter(item -> "北京".equals(item.getTrader().getCity()))
                .collect(Collectors.summingInt(Transaction::getValue));
        System.out.println(collect);
    }

    @Test
    public void t7(){
        // 7.所有的交易额中，最高的交易额是多少？
        // 方法一
        Optional<Integer> collect = transactionList.stream()
                .map(item -> item.getValue())
                .collect(Collectors.maxBy(Integer::compareTo));
        System.out.println(collect.get());

        // 方法二
//        Optional<Integer> collect = transactionList.stream()
//                .map(item -> item.getValue())
//                .max(Integer::compareTo);
//        System.out.println(collect.get());

        // 方法三
        Optional<Integer> optional = transactionList.stream()
                .map(item -> item.getValue())
                .reduce((a, b) -> a > b ? a : b);
        System.out.println(optional);
    }

    @Test
    public void t8(){
        // 8.所有的交易额中，找到交易额最小的交易
        Optional<Integer> min = transactionList.stream()
                .map(item -> item.getValue())
                .min(Integer::compareTo);
        System.out.println(min);
    }
}
